package com.seeyon.ctp.rest.resources;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.seeyon.apps.dzdd.kit.StrKit;
import com.seeyon.apps.dzdd.manager.AssetsInventoryManager;
import com.seeyon.ctp.common.AppContext;
import com.seeyon.ctp.common.ctpenumnew.manager.EnumManager;
import com.seeyon.ctp.common.log.CtpLogFactory;
import com.seeyon.ctp.common.po.ctpenumnew.CtpEnumBean;
import com.seeyon.ctp.common.po.ctpenumnew.CtpEnumItem;
import org.apache.commons.logging.Log;

import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Path("jssdk")
@Produces({MediaType.APPLICATION_JSON})
public class CustomBpmFlowResources extends BaseResource {

    private static final Log log = CtpLogFactory.getLog(CustomBpmFlowResources.class);

    private EnumManager enumManager = (EnumManager) AppContext.getBean("enumManagerNew");
    private AssetsInventoryManager assetsInventoryManager = (AssetsInventoryManager) AppContext.getBean("assetsInventoryManager");

    /**
     * 查询资产盘点计划的数据接口
     * 该方法通过POST请求接收客户端传入的查询参数，返回相应的资产盘点计划列表
     *
     * @param param 包含查询条件的参数映射表，客户端通过JSON格式传入
     * @return 根据查询结果生成的响应对象，包含成功或失败的信息以及数据列表
     * @throws Exception 在处理请求过程中可能抛出的异常
     */
    @POST
    @Path("find/AssetsInventoryplan/datas")
    @Consumes(MediaType.APPLICATION_JSON)
    public Response findAssetsInventoryplan(Map<String, Object> param) throws Exception {
        // 记录日志，输出接收到的查询参数
        log.info("资产盘点计划前端入参:" + JSON.toJSONString(param));

        // 初始化用于返回给前端的结果映射
        Map<String, Object> resultMap = new HashMap<String, Object>();

        // 将接收到的参数映射转换为JSONObject以便操作
        JSONObject jsonObject = new JSONObject(param);

        // 默认情况下，memberId为空字符串
        String memberId = "";

        // 检查JSON对象中是否包含"memberId"字段
        if (jsonObject.containsKey("memberId")) {
            // 如果存在，将该字段值转换为字符串
            memberId = StrKit.str(jsonObject.get("memberId"));
        }

        // 如果memberId为空，返回错误提示
        if (memberId.equals("")) {
            resultMap.put("type", "E");
            resultMap.put("msg", "[memberId]人员ID不能为空!");
            return ok(JSON.toJSONString(resultMap));
        }

        // 调用业务逻辑层方法，根据查询参数获取资产盘点计划列表
        List<Map<String, Object>> dataList = assetsInventoryManager.getAssetsInventoryplanList(param);

        // 准备返回结果，指示查询成功
        resultMap.put("type", "S");
        resultMap.put("msg", "");
        resultMap.put("data", dataList);

        // 返回包含查询结果的响应对象
        return ok(resultMap);
    }

    /**
     * 查询资产的状态、类型和位置信息
     * 该方法接收一个JSON对象作为参数，返回一个包含资产状态、类型和位置信息的JSON对象
     *
     * @param param 包含查询参数的JSON对象
     * @return 包含资产状态、类型和位置信息的JSON对象
     * @throws Exception 如果查询过程中发生错误
     */
    @POST
    @Path("find/Assets/status/type/location/itemDatas")
    @Consumes(MediaType.APPLICATION_JSON)
    public Response findStatusTypeLocationItemDatas(Map<String, Object> param) throws Exception {
        // 初始化结果对象
        Map<String, Object> resultMap = new HashMap<String, Object>();
        // 设置结果类型为成功
        resultMap.put("type", "S");
        // 初始化结果消息为空
        resultMap.put("msg", "");
        // 初始化数据对象
        Map<String, Object> dataMap = new HashMap<String, Object>();
        // 资产状态
        dataMap.put("zcztData", getEnumItems("ZiChanZhuangTai"));
        // 资产类别
        dataMap.put("zclbData", getEnumItems("ZiChanLeiBie"));
        // 存放位置
        dataMap.put("cfwzData", getEnumItems("CunFangWeiZhi"));
        // 将数据对象放入结果对象
        resultMap.put("data", dataMap);
        // 返回成功响应
        return ok(resultMap);
    }

    /**
     * 通过HTTP POST方法获取部门下的资产信息
     *
     * @param param 包含查询参数的Map，可能包含assetsDeptId和isDetails
     * @return 根据查询参数返回资产信息的Response对象
     * @throws Exception 如果发生异常，则抛出
     */
    @POST
    @Path("find/dept/Assets/datas")
    @Consumes(MediaType.APPLICATION_JSON)
    public Response findDeptAssetsDatas(Map<String, Object> param) throws Exception {
        // 记录获取部门资产信息的前端入参
        log.info("获取部门下资产信息前端入参:" + JSON.toJSONString(param));

        // 将参数Map转换为JSONObject以便于处理
        JSONObject jsonObject = new JSONObject(param);

        // 初始化返回的结果Map
        Map<String, Object> resultMap = new HashMap<String, Object>();

        // 默认部门ID为空
        String assetsDeptId = "";

        // 检查参数中是否包含assetsDeptId，如果有则赋值
        if (jsonObject.containsKey("assetsDeptId")) {
            assetsDeptId = StrKit.str(jsonObject.get("assetsDeptId"));
        }

        // 如果assetsDeptId为空，则返回错误信息
        if (assetsDeptId.equals("")) {
            resultMap.put("type", "E");
            resultMap.put("msg", "[assetsDeptId]资产部门不能为空!");
            return ok(resultMap);
        }
        String planNumber = "";
        if (jsonObject.containsKey("planNumber")) {
            planNumber = StrKit.str(jsonObject.get("planNumber"));
        }

        if (planNumber.equals("")) {
            resultMap.put("type", "E");
            resultMap.put("msg", "[planNumber]计划编号不能为空!");
            return ok(resultMap);
        }

        // 获取是否需要详细信息的参数
        String isDetails = StrKit.str(jsonObject.get("isDetails"));

        // 如果需要详细信息，则从数据库获取详细信息列表
        if ("true".equals(isDetails)) {
            List<Map<String, Object>> dataList = (List<Map<String, Object>>) assetsInventoryManager.getDeptAssetsDatasList(param, true);
            resultMap.put("data", dataList);
        } else {
            // 如果不需要详细信息，则从数据库获取汇总信息
            Map<String, Object> dataMap = (Map<String, Object>) assetsInventoryManager.getDeptAssetsDatasList(param, false);
            resultMap.put("data", dataMap);
        }

        // 设置成功返回信息的标志和消息
        resultMap.put("type", "S");
        resultMap.put("msg", "");

        // 返回包含资产信息的响应
        return ok(resultMap);
    }

    /**
     * 根据资产编号查找资产数据
     *
     * @param param 包含查询参数的Map
     * @return 包含查询结果的响应对象
     * @throws Exception 如果发生异常，则向上抛出异常
     */
    @POST
    @Path("find/Assets/byAssetsCode/datas")
    @Consumes(MediaType.APPLICATION_JSON)
    public Response findAssetsDatas(Map<String, Object> param) throws Exception {
        // 记录资产盘点前端参数
        log.info("根据资产编码查询资产信息前端入参:" + JSON.toJSONString(param));
        // 将参数映射转换为JSONObject以便于操作
        JSONObject jsonObject = new JSONObject(param);
        // 用于存储操作结果的映射
        Map<String, Object> resultMap = new HashMap<String, Object>();
        String assetsCode = "";
        // 检查资产编号是否存在
        if (jsonObject.containsKey("assetsCode")) {
            assetsCode = StrKit.str(jsonObject.get("assetsCode"));
        }
        if (assetsCode.equals("")) {
            // 资产编号为空时，返回错误信息
            resultMap.put("type", "E");
            resultMap.put("msg", "[assetsCode]资产编号不能为空!");
            resultMap.put("data", new HashMap<String, Object>());
            return ok(resultMap);
        }
        String assetsDeptId = "";
        if (jsonObject.containsKey("assetsDeptId")) {
            assetsDeptId = StrKit.str(jsonObject.get("assetsDeptId"));
        }
        if (assetsDeptId.equals("")) {
            // 资产部门为空时，返回错误信息
            resultMap.put("type", "E");
            resultMap.put("msg", "[assetsDeptId]盘点部门不能为空!");
            resultMap.put("data", new HashMap<String, Object>());
            return ok(resultMap);
        }
        String planNumber = "";
        if (jsonObject.containsKey("planNumber")) {
            planNumber = StrKit.str(jsonObject.get("planNumber"));
        }
        if (planNumber.equals("")) {
            // 盘点计划单号为空时，返回错误信息
            resultMap.put("type", "E");
            resultMap.put("msg", "[planNumber]盘点计划单号不能为空!");
            return ok(resultMap);
        }
        Map<String, Object> assetsMap = assetsInventoryManager.getAssetsByAssetsCode(assetsCode, assetsDeptId, planNumber);
        return ok(assetsMap);
    }

    /**
     * 创建或更新资产盘点数据
     *
     * @param param 包含资产盘点相关信息的参数映射
     * @return 返回响应对象，包含操作结果
     * @throws Exception 在操作过程中可能抛出的异常
     */
    @POST
    @Path("AssetsInventory/data/createOrUpdate")
    @Consumes(MediaType.APPLICATION_JSON)
    public Response createOrUpdateAssetsInventory(Map<String, Object> param) throws Exception {
        // 记录资产盘点前端参数
        log.info("资产盘点前端入参:" + JSON.toJSONString(param));
        // 将参数映射转换为JSONObject以便于操作
        JSONObject jsonObject = new JSONObject(param);
        // 用于存储操作结果的映射
        Map<String, Object> resultMap = new HashMap<String, Object>();
        String assetsCode = "";
        // 检查资产编号是否存在
        if (jsonObject.containsKey("assetsCode")) {
            assetsCode = StrKit.str(jsonObject.get("assetsCode"));
        }
        if (assetsCode.equals("")) {
            // 资产编号为空时，返回错误信息
            resultMap.put("type", "E");
            resultMap.put("msg", "[assetsCode]资产编号不能为空!");
            return ok(resultMap);
        }
        String planNumber = "";
        // 检查盘点计划单号是否存在
        if (jsonObject.containsKey("planNumber")) {
            planNumber = StrKit.str(jsonObject.get("planNumber"));
        }
        if (planNumber.equals("")) {
            // 盘点计划单号为空时，返回错误信息
            resultMap.put("type", "E");
            resultMap.put("msg", "[planNumber]盘点计划单号不能为空!");
            return ok(resultMap);
        }
        String inventoryMemberId = "";
        // 检查盘点人ID是否存在
        if (jsonObject.containsKey("inventoryMemberId")) {
            inventoryMemberId = StrKit.str(jsonObject.get("inventoryMemberId"));
        }
        if (inventoryMemberId.equals("")) {
            // 盘点人为空时，返回错误信息
            resultMap.put("type", "E");
            resultMap.put("msg", "[inventoryMemberId]盘点人不能为空!");
            return ok(resultMap);
        }
        String assetsDeptId = "";
        // 检查资产部门ID是否存在
        if (jsonObject.containsKey("assetsDeptId")) {
            assetsDeptId = StrKit.str(jsonObject.get("assetsDeptId"));
        }
        if (assetsDeptId.equals("")) {
            // 资产部门为空时，返回错误信息
            resultMap.put("type", "E");
            resultMap.put("msg", "[assetsDeptId]资产部门不能为空!");
            return ok(resultMap);
        }
        // 检查资产ID是否存在
        String assetsId = "";
        if (jsonObject.containsKey("assetsId")) {
            assetsId = StrKit.str(jsonObject.get("assetsId"));
        }
        if (assetsId.equals("")) {
            // 资产ID为空时，返回错误信息
            resultMap.put("type", "E");
            resultMap.put("msg", "[assetsId]资产ID不能为空!");
            return ok(resultMap);
        }

        // 执行添加或更新资产盘点数据操作
        Map<String, Object> update_resultMap = assetsInventoryManager.addOrUpdateAssetsInventory(param);
        return ok(update_resultMap);

    }

    private List<Map<String, Object>> getEnumItems(String ctpEnumCode) throws Exception {
        CtpEnumBean zczt_ctpEnumBean = enumManager.getEnumByProCode(ctpEnumCode);
        List<CtpEnumItem> zczt_ctpEnumItems = enumManager.getEmumItemByEmumId(zczt_ctpEnumBean.getId());
        List<Map<String, Object>> zczt_dataList = new ArrayList<Map<String, Object>>();
        for (CtpEnumItem zczt_ctpEnumItem : zczt_ctpEnumItems) {
            Map<String, Object> zczt_map = new HashMap<String, Object>();
            zczt_map.put("id", StrKit.str(zczt_ctpEnumItem.getId()));
            zczt_map.put("name", zczt_ctpEnumItem.getShowvalue());
            zczt_dataList.add(zczt_map);
        }
        return zczt_dataList;
    }
}
